module neo.typescript {
	/**
	 *
	 * @author 
	 *
	 */
	export class Color {
        public static RED:number = 0xFF0000;

        public static GREEN:number = 0x00FF00;

        public static BLUE:number = 0x0000FF;

        public static randomColor():number {
            return Color.RGB(Math.floor(Math.random() * 256),Math.floor(Math.random() * 256),Math.floor(Math.random() * 256));
        }
		
		/**
		 * 合并颜色值
		 *
		 * @param r	红
		 * @param g	绿
		 * @param b	蓝
		 * @return	返回一个新的颜色值
		 *
		 */
        public static RGB(r:number,g:number,b:number):number {
            return(r << 16) | (g << 8) | b;
        }
    
        /**
         * 通过色度的方法合并颜色值。
         * 我也一直无法熟练混合光度三原色，毕竟调色的时候用的不是这种，这个方法就算图个方便了。
         * 仍然采用Red,Blue这种缩写，是因为这是针对程序员的
         *
         * @param r	红（品红 Magenta）
         * @param y	黄（黄 Yellow）
         * @param b 蓝（青 Cyan）
         * @return	返回一个新的颜色值
         *
         */
        public static RYB(r: number,y: number,b: number): number {
            return ((0xFF - b) << 16) | ((0xFF - r) << 8) | (0xFF - y);
        }
    
        /**
         * 获得单个通道的颜色
         *
         * @param rgb	颜色值
         * @param channel	颜色通道，数值为RED,GREEN,BLUE常量之一
         * @return 返回颜色
         *
         */
        public static getChannel(rgb: number,channel: number): number {
            switch(channel) {
                case Color.RED:
                    return (rgb >> 16) & 0xFF;
                    break;
                case Color.GREEN:
                    return (rgb >> 8) & 0xFF;
                    break;
                case Color.BLUE:
                    return rgb & 0xFF;
                    break;
            }
            return 0;
        }
    
//        /**
//         * 从一个24位颜色值创建对应的ColorTransform对象，方法为过滤
//         * 注意，此对象会重置alpha
//         *
//         * @param rgb	颜色值
//         * @param alpha	透明度
//         */
//        public static getColorTransform(rgb: number,alpha: number = 1.0): ColorTransform {
//            var r: number = (rgb >> 16) & 0xFF;
//            var g: number = (rgb >> 8) & 0xFF;
//            var b: number = rgb & 0xFF;
//    
//            return new ColorTransform(r / 0xFF,g / 0xFF,b / 0xFF,alpha);
//        }
//    
//        /**
//         * 从一个24位颜色值创建对应的ColorTransform对象，方法为附加
//         * 注意，此对象会重置alpha
//         *
//         * @param rgb	颜色值
//         * @param alpha	附加颜色的透明度
//         */
//        public static getColorTransform2(rgb: number,alpha: number = 1.0): ColorTransform {
//            var r: number = (rgb >> 16) & 0xFF * alpha;
//            var g: number = (rgb >> 8) & 0xFF * alpha;
//            var b: number = rgb & 0xFF * alpha;
//    
//            return new ColorTransform(1.0,1.0,1.0,1.0,r,g,b);
//        }
    
    
        /**
         * 单独调整某个颜色通道
         *
         * @param channel	颜色通道，数值为RED,GREEN,BLUE常量之一，可以用 | 符号多选
         * @param rgb	颜色值
         * @param brite	颜色变化量
         * 这个值表示的是颜色的数值增加量，数值由-255至255，为0则不改变。
         * @return	返回一个新的颜色值
         */
        public static adjustColor(channel: number,rgb: number,brite: number): number {
            var r: number;
            var g: number;
            var b: number;
    
            if((Color.RED & channel) == channel) {
                r = Math.max(Math.min(((rgb >> 16) & 0xFF) + brite,255),0);
            } else {
                r = (rgb >> 16) & 0xFF;
            }
    
            if((Color.GREEN & channel) == channel) {
                g = Math.max(Math.min(((rgb >> 8) & 0xFF) + brite,255),0);
            } else {
                g = (rgb >> 8) & 0xFF;
            }

            if((Color.BLUE & channel) == channel) {
                b = Math.max(Math.min((rgb & 0xFF) + brite,255),0);
            } else {
                b = rgb & 0xFF;
            }
            return Color.RGB(r,g,b);
        }
    
        /**
         * 调整亮度
         *
         * @param rgb	颜色值
         * @param brite	颜色变化量
         * 这个值表示的是颜色的数值增加量，数值由-255至255，为0则不改变。
         * @return	返回一个新的颜色值
         */
        public static adjustBrightnessByValue(rgb: number,brite: number): number {
            var r: number = Math.max(Math.min(((rgb >> 16) & 0xFF) + brite,255),0);
            var g: number = Math.max(Math.min(((rgb >> 8) & 0xFF) + brite,255),0);
            var b: number = Math.max(Math.min((rgb & 0xFF) + brite,255),0);
    
            return Color.RGB(r,g,b);
        }

        /**
         * 按比例调整亮度的方式
         *
         * @param rgb	颜色值
         * @param brite	颜色变化量
         * 这个值表示的是颜色的比例系数，数值由-100至100，为0则不改变。
         * @return	返回一个新的颜色值
         */
        public static adjustBrightnessByPercent(rgb: number,brite: number): number {
            var r: number;
            var g: number;
            var b: number;
    
            if(brite == 0)
                return rgb;
    
            if(brite < 0) {
                brite = (100 + brite) / 100;
                r = ((rgb >> 16) & 0xFF) * brite;
                g = ((rgb >> 8) & 0xFF) * brite;
                b = (rgb & 0xFF) * brite;
            } else {
                brite /= 100;
                r = ((rgb >> 16) & 0xFF);
                g = ((rgb >> 8) & 0xFF);
                b = (rgb & 0xFF);
    
                r += ((0xFF - r) * brite);
                g += ((0xFF - g) * brite);
                b += ((0xFF - b) * brite);
    
                r = Math.min(r,255);
                g = Math.min(g,255);
                b = Math.min(b,255);
            }
    
            return Color.RGB(r,g,b);
        }
    
        /**
         *  用正片叠底的方式合并两个颜色值
         *  用这种方法合并的颜色值纯度将会降低
         *
         *  @param rgb1 第一个颜色值
         *  @param rgb2 第二个颜色值
         *  @return 合并结果
         */
        public static rgbMultiply(rgb1: number,rgb2: number): number {
            var r1: number = (rgb1 >> 16) & 0xFF;
            var g1: number = (rgb1 >> 8) & 0xFF;
            var b1: number = rgb1 & 0xFF;
    
            var r2: number = (rgb2 >> 16) & 0xFF;
            var g2: number = (rgb2 >> 8) & 0xFF;
            var b2: number = rgb2 & 0xFF;
    
            return ((r1 * r2 / 255) << 16) | ((g1 * g2 / 255) << 8) | (b1 * b2 / 255);
        }
    
//        /**
//         * 获得调色板数组
//         *
//         * @param colors
//         * @param alphas
//         * @param rations
//         * @return
//         *
//         */
//        public static getPaletteArray(colors: Array,alphas: Array,rations: Array): Array {
//            var m: Matrix = new Matrix();
//            m.createGradientBox(256,1);
//    
//            var s: Shape = new Shape();
//            s.graphics.beginGradientFill(GradientType.LINEAR,colors,alphas,rations,m);
//            s.graphics.drawRect(0,0,256,1);
//            s.graphics.endFill();
//    
//            var bitmap: BitmapData = new BitmapData(256,1);
//            bitmap.draw(s);
//    
//            var result: Array = [];
//            for(var i: int = 0;i < 256;i++)
//                result.push(bitmap.getPixel(i,0));
//    
//            bitmap.dispose();
//            return result;
//        }
    
        /**
         * 获得两个颜色的中间值
         *
         * @param rgb1	第一个颜色
         * @param rgb2	第二个颜色
         * @param ratio	第二个颜色的比例
         *
         */
        public static getColorBetween(rgb1: number,rgb2: number,ratio: number): number {
            var r1: number = (rgb1 >> 16) & 0xFF;
            var g1: number = (rgb1 >> 8) & 0xFF;
            var b1: number = rgb1 & 0xFF;
    
            var r2: number = (rgb2 >> 16) & 0xFF;
            var g2: number = (rgb2 >> 8) & 0xFF;
            var b2: number = rgb2 & 0xFF;
    
            return ((r1 + (r2 - r1) * ratio) << 16) | ((g1 + (g2 - g1) * ratio) << 8) | ((b1 + (b2 - b1) * ratio));
        }
    
		public constructor() {
		}
	}
}
